#ifndef __M_SERVER_H
#define __M_SERVER_H
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <unordered_map>
#include <sys/stat.h>
#include <cstring>
#include <cassert>
#include <signal.h>
#include <ctime>
#include <regex>
#include <functional>
#include <fcntl.h>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <memory>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>
#include <typeinfo>
// #include <Any>

#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL INF
#define LOG(level, format, ...) do{\
        if (level < LOG_LEVEL) break;\
        time_t t = time(nullptr);\
        struct tm* ltm = localtime(&t);\
        char tmp[32] = {0};\
        strftime(tmp, 31, "%H:%M:%S", ltm);\
        fprintf(stdout, "[%p %s %s:%d] " format "\n", (void*)pthread_self(), tmp, __FILE__, __LINE__, ##__VA_ARGS__);\
    }while(0)
#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)




#define BUFFER_DEFAULT_SIZE 1024

class Buffer { 
private:
    std::vector<char> _buffer; // 使用vector进行内存空间管理
    uint64_t _reader_idx; // 读偏移
    uint64_t _writer_idx; //写偏移
public:
    Buffer():_reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    char* Begin() { return &*_buffer.begin(); }
    // 获取当前写入起始地址 -- _buffer的空间起始地址，加上写偏移量
    char* WritePosition() { return Begin() + _writer_idx; }
    // 获取当前读取起始地址 -- _buffer的空间起始地址，加上读偏移量
    char* ReadPosition() { return Begin() + _reader_idx; }
    // 获取缓冲区末尾空闲空间大小 -- 写偏移之前的空闲空间 -- 总体空间大小减去写偏移
    uint64_t TailIdleSize() { return _buffer.size() - _writer_idx; }
    // 获取缓冲区头部空闲空间大小 -- 读偏移之前的空闲空间
    uint64_t HeadIdleSize() { return _reader_idx; }
    // 获取可读数据大小
    uint64_t ReadableSize() { return _writer_idx - _reader_idx; }
    // 读偏移向后移动
    void MoveReadOffset(uint64_t len) { 
        if (len == 0) return;
        // 向后移动的大小，必须小于可读数据的大小
        assert(len <= ReadableSize()); 
        _reader_idx += len; 
    }
    // 写偏移向后移动
    void MoveWriteOffset(uint64_t len) {
        // 向后移动大小必须小于当前后面空闲空间的大小
        assert(len <= TailIdleSize());
        _writer_idx += len;
    }
    // 确保可写空间足够 (整体空闲空间够了就移动数据，否则就扩容)
    void EnsureWriteSpace(uint64_t len) {
        // 如果末尾空闲空间大小足够，直接返回
        if (TailIdleSize() >= len) {
            return;
        }
        // 如果不够，则加上起始位置的空闲空间大小，判断是否足够,够了将数据移动到起始位置
        if (len <= TailIdleSize() + HeadIdleSize()) {
            // 将数据移动到起始位置
            uint64_t rsz = ReadableSize();// 先把当前数据大小保存起来
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin()); // 把可读数据拷贝到起始位置
            _reader_idx = 0;        // 将读偏移归零
            _writer_idx = rsz;       // 将写位置置为可读数据大小，因为当前的可读数据大小就是写偏移量
        }else {
            // 总体空间不够需要扩容，不移动数据，直接给写偏移之后扩容足够空间
            _buffer.resize(_writer_idx + len);
        }
    }
    // 写入数据
    void Write(const void* data, uint64_t len) {
        // 1.保证有足够空间 2.拷贝数据进去
        if (len == 0) return;
        EnsureWriteSpace(len);
        const char* d = (const char*)data;
        std::copy(d, d + len, WritePosition());
    }
    void WriteAndPush(const void* data, uint64_t len) {
        Write(data, len);
        MoveWriteOffset(len);
    }
    // 
    void WriteString(const std::string& data) {
        return Write(data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string& data) {
        WriteString(data);
        MoveWriteOffset(data.size());
    }
    //
    void WriteBuffer(Buffer& data) {
        return Write(data.ReadPosition(), data.ReadableSize());
    }
    void WriteBufferAndPush(Buffer& data) {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadableSize());
    }
    // 读取数据
    void Read(void* buf, uint64_t len) {
        // 要求获取的数据大小必须小于可读数据大小
        assert(len <= ReadableSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char*)buf);
    }
    //
    void ReadAndPop(void* buf, uint64_t len) {
        Read(buf, len);
        MoveReadOffset(len);
    }
    //
    std::string ReadAsString(uint64_t len) {
        assert(len <= ReadableSize());
        std::string str;
        str.resize(len);
        // str.c_str()会返回一个const char* 不允许我们去修改所指向空间的内容，
        // 所以使用&str[0](类型重载,函数重载)绕过从const char*获取空间的首地址
        Read(&str[0], len);

        return str;
    }
    std::string ReadAsStringAndPop(uint64_t len) {
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }
    // 寻找换行字符
    char* FindCRLF() {
        char* res = (char*)memchr(ReadPosition(), '\n', ReadableSize());
        return res;
    }
    // 返回一行数据，这种情况针对的是ASCII字符
    std::string GetLine() {
        char* pos = FindCRLF();
        if (pos == nullptr) {
            return "";
        }
        // +1是为了把换行字符取出来 pos - ReadPosition()是换行字符前面的字符的长度，+1就是把换行字符也带上
        return ReadAsString(pos - ReadPosition() + 1); 
    }
    std::string GetLineAndPop() {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }
    // 清空缓冲区 -- 归零覆盖写入
    void Clear() { _writer_idx = 0, _reader_idx = 0; }
};

#define MAX_LISTEN 1024
class Socket {
private:
    int _sockfd;
public:
    Socket():_sockfd(-1) {}
    Socket(int fd):_sockfd(fd) {}
    ~Socket() { Close(); }
    int Fd() { return _sockfd; }
    // 创建套接字
    bool Create() {
        //int socket
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0) {
            ERR_LOG("CREATE SOCKET FAILED!");
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string& ip, uint16_t port) {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        //int bind
        int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
        if(ret < 0) {
            ERR_LOG("BIND ADDRESS FAILED!");
            return false;
        }
        return true;
    }
    // 开始监听
    bool Listen(int backlog = MAX_LISTEN) {
        // int listen(int backlog)
        int ret = listen(_sockfd, backlog);
        if (ret < 0) {
            ERR_LOG("SOCKET LISTEN FAILED!");
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string& ip, uint16_t port) {
        //int connect ()
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        //int bind
        int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
        if(ret < 0) {
            ERR_LOG("CONNECT SERVER FAILED!");
            return false;
        }
        return true;
    }
    // 获取新连接
    int Accept() {
        // int accept ()
        int newfd = accept(_sockfd, nullptr, nullptr);
        if(newfd < 0) {
            ERR_LOG("SOCKET ACCEPT FAILED!");
            return -1;
        }
        return newfd;
    }
    // 接收数据
    ssize_t Recv(void* buf, size_t len, int flag = 0) {
        //ssize_t recv ()
        ssize_t ret = recv(_sockfd, buf, len, flag);
        //小于0 - 出错， 等于0 - 断开
        if (ret <= 0) {
            // EAGAIN - 当前SOCKET的接收缓冲区没有数据了，在非阻塞的情况下才会有这个错误
            // EINTR - 当前的阻塞等待，被信号打断了， 
            if(errno == EAGAIN || errno == EINTR) {
                return 0; // 表示这次没有接收到数据
            }
            ERR_LOG("SOCKET RECV FAILED!");
            return -1;
        }
        return ret; // 实际接收的数据长度
    }
    ssize_t NonBlockRecv(void* buf, size_t len) {
        return Recv(buf, len, MSG_DONTWAIT);// MSG_DONTWAIT表示当前接收为非阻塞，没有数据报错返回
    }
    // 发送数据
    ssize_t Send(const void* buf, size_t len, int flag = 0) {
        //ssize_t send(int sockfd, void* data, size)t len)
        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret < 0) {
            // EINTR -- 被信号打断 EAGAIN-- 无数据可读
            if (errno == EINTR || errno == EAGAIN) {
            return 0;
        }
            ERR_LOG("SOCKET SEND FAILED!");
            return -1;
        }
        return ret; // 实际发送的数据长度
    }
    ssize_t NonBlockSend(void* buf, size_t len) {
        if (len == 0) return 0;
        return Send(buf, len, MSG_DONTWAIT);// MSG_DONTWAIT表示当前发送为非阻塞
    }
    // 关闭套接字
    void Close() {
        if(_sockfd != -1) {
            close(_sockfd);
            _sockfd = -1;
        }
    }
    // 创建一个服务端连接
    bool CreateServer(uint16_t port, const std::string& ip = "0.0.0", bool block_flag = false) {
        // 1.创建套接字， 2.绑定地址， 3.开始监听， 4.设置非阻塞， 5.启动地址重用
        if (Create() == false) return false;
        if (block_flag) NonBlock();
        if (Bind(ip, port) == false) return false;
        if (Listen() == false) return false;
        ReuseAddress();
        return true;
    }
    // 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string& ip) {
        // 1.创建套接字， 2.连接服务器
        if (Create() == false) return false;
        if(Connect(ip, port) == false) return false;
        return true;
    }
    // 设置套接字选项 -- 开启地址端口重用
    void ReuseAddress() {
        // int setsockopt(int fd, int level, int optname, void* val, int vallen)
        int val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&val, sizeof(int));
        val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void*)&val, sizeof(int));

    }
    // 设置套接字阻塞属性 -- 设置为非阻塞
    void NonBlock() {
        // int fcntl(int fd, int cmd, ...)
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }
};
class Poller;
class EventLoop;
class Channel {
private:
    int _fd;
    EventLoop* _loop;
    uint32_t _events; // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    EventCallback _read_callback; // 可读事件被触发的回调函数
    EventCallback _write_callback; // 可写事件被触发的回调函数
    EventCallback _error_callback; // 错误事件被触发的回调函数
    EventCallback _close_callback; // 连接断开事件被触发的回调函数
    EventCallback _evevt_callback; // 任意事件被触发的回调函数
public:
    Channel(EventLoop* loop, int fd):_fd(fd), _events(0), _revents(0), _loop(loop) {}
    int Fd() { return _fd; }
    void SetREvents(uint32_t events) { _revents = events; } // 设置实际就绪的事件
    uint32_t Events() { return _events; } // 获取想要监控的事件
    void SetReadCallback(const EventCallback& cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback& cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback& cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback& cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback& cb) { _evevt_callback = cb; }
    // 当前是监控否可读
    bool ReadAble() { return (_events & EPOLLIN); }
    // 当前是否监控可写
    bool WriteAble() { return (_events & EPOLLOUT); }
    // 启动读事件监控
    void EnableRead() { _events |= EPOLLIN; Update();/*后续添加到EventLoop的事件监控中*/}
    // 启动写事件监控
    void EnableWrite() { _events |= EPOLLOUT; Update();/*后续添加到EventLoop的事件监控中*/}
    // 解除可读事件监控
    void DisableRead() { _events &= ~EPOLLIN; Update();/*后续修改到EventLoop的事件监控中*/ }
    // 解除可写事件监控
    void DisableWrite() { _events &= ~EPOLLOUT; Update();/*后续修改到EventLoop的事件监控中*/ }
    // 解除所有事件监控
    void DisableAll() { _events = 0; }
    // 移除监控 -- 从epoll的红黑树上移除
    void Remove();
    void Update();
    // 事件处理，一旦触发了事件，就调用这个函数，自己处理什么事件，如何处理，自己决定
    void HandleEvent() {
        if((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI)) {
            /*任意事件都调用的回调函数*/
            if(_evevt_callback) _evevt_callback();
            if(_read_callback) _read_callback();
        }
        // 有可能让连接断开的事件，一次只处理一个
        if(_revents & EPOLLOUT) {
            /*任意事件都调用的回调函数*/
            if(_evevt_callback) _evevt_callback(); // 放到事件处理完毕后调用，刷新活跃度
            if(_write_callback) _write_callback();
        }else if(_revents & EPOLLERR) {
             /*任意事件都调用的回调函数*/
            if(_evevt_callback) _evevt_callback();

            if(_error_callback) _error_callback(); // 一旦出错就会释放连接，没必要调用任意回调了，因此放到前边
        }else if(_revents & EPOLLHUP) {
             /*任意事件都调用的回调函数*/
            if(_evevt_callback) _evevt_callback();

            if(_close_callback) _close_callback();
        }
    }
};
#define MAX_EPOLLEVENTS 1024
class Poller {
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel*> _channels;
private:
    // 对epoll的直接操作
    void Update(Channel* channel, int op) {
        // int epoll_ctl()
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0) {
            ERR_LOG("EPOLLCTL FAILED!");
            // abort(); // 退出程序
        }
        return;
    }
    // 判断一个Channel是否已经添加了事件监控
    bool HasChannel(Channel* channel) {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end()) {
            return false;
        }
        return true;
    }
public:
    Poller() {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if(_epfd < 0) {
            ERR_LOG("EPOLL CREATE FAILED!");
            abort(); // 退出程序
        }
    }
    // 添加或修改监控事件
    void UpdateEvents(Channel* channel) {
        bool ret = HasChannel(channel);
        if (ret == false) {
            //不存在则添加，存在则更新
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }
    // 移除监控
    void RemoveEvent(Channel* channel) {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end()) {
            _channels.erase(it);
        }
        Update(channel, EPOLL_CTL_DEL);
    }
    // 开始监控返回活跃连接
    void Poll(std::vector<Channel*>* active) {
        // int epoll_wait()

        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
        if (nfds < 0) {
            if (errno == EINTR) {
                return;
            }
            ERR_LOG("EPOLL WAIT ERROR:%s\n", strerror(errno));
            abort();
        }
        for(int i = 0; i < nfds; i++) {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetREvents(_evs[i].events); // 设置实际就绪的事件
            active->push_back(it->second);
        }
        return;
    }
};

using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimerTask
{
private:
    uint64_t _id;       // 定时器任务对象Id
    uint32_t _timeout;  // 定时任务的超时时间
    bool _canceled;     // false-表示没有被取消，true-表示被取消
    TaskFunc _task_cb;  // 定时器对象要执行的定时任务 
    ReleaseFunc _release;// 用于删除TimerWheel中保存的定时器对象信息
public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc& cb)
    :_id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}
    ~TimerTask() 
    {
        if(_canceled == false) _task_cb();
        _release(); 

    }
    void Cancel() { _canceled = true; }
    void SetRelease(const ReleaseFunc& cb) { _release = cb; }
    uint32_t DelayTime() { return _timeout; }
};

//时间轮
using WeakTask = std::weak_ptr<TimerTask>;
using PtrTask = std::shared_ptr<TimerTask>;
class TimerWheel
{
private:
    int _tick;      // 当前的秒针，走到哪释放哪里，相当于执行哪里的任务
    int _capacity;  // 表盘的最大数量，也就是最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;
    std::unordered_map<uint64_t, WeakTask> _timers;

    EventLoop* _loop;
    int _timerfd; // 定时器描述符 -- 可读事件回调就是读取计数器，执行定时任务
    std::unique_ptr<Channel> _timer_channel;

private:
    void RemoveTimer(uint64_t id) {
        auto it = _timers.find(id);
        if(it != _timers.end()) {
            _timers.erase(id);
        }
    }
    static int CreateTimerfd() {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if(timerfd < 0) {
            ERR_LOG("TIMERFD CREATE FAILED!");
            abort();
        }
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0; // 第一次超时时间为1s后
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0; // 第一次超时后，每次超时的间隔
        timerfd_settime(timerfd, 0, &itime, nullptr);
        return timerfd;
    }
    void ReadTimerfd() {
        uint64_t times;
        int ret = read(_timerfd, &times, 8);
        if(ret < 0) {
            ERR_LOG("READ TIMERFD FAILED!");
            abort();
        }
        return;
    }
    // 每秒被执行一次
    void RunTimerTask() {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear();  // 清空指定位置上的数组，就会把数组里的所有管理定时器的对象的share_ptr释放掉 
    }
    void OnTime() {
        ReadTimerfd();
        RunTimerTask();
    }
    // 添加定时任务
    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc& cb) {
        PtrTask pt(new TimerTask(id, delay, cb));
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
        _timers[id] = WeakTask(pt);
    }
    // 刷新/延迟定时任务
    void TimerRefreshInLoop(uint64_t id)  {
        // 通过保存的定时器对象的weak_ptr构造一个share_ptr出来，添加到轮子中
        auto it = _timers.find(id);
        if(it == _timers.end()) {
            return; // 没找到，没法刷新，没法延迟
        }
        PtrTask pt = it->second.lock(); // lock获取weak_ptr管理的对象的share_ptr
        int delay = pt->DelayTime();
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }
    void TimerCancelInLoop(uint64_t id) {
        auto it = _timers.find(id);
        if(it == _timers.end()) {
            return; // 没找到，没法刷新，没法延迟
        }
        PtrTask pt = it->second.lock();
        if(pt) pt->Cancel();
    }
public:
    TimerWheel(EventLoop* loop):_capacity(60), _tick(0), _wheel(_capacity), _loop(loop), _timerfd(CreateTimerfd()), _timer_channel(new Channel(_loop, _timerfd)) {
        // _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->EnableRead(); // 启动读事件监控
    }
    // 定时器中有个timers成员，定时器信息的操作有可能在多线程中进行，因此需要考虑线程安全问题，不想加锁就把定时器的所有操作，放到一个线程中进行
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cb);
    void TimerRefresh(uint64_t id);
    void TimerCancel(uint64_t id);
    // 存在线程安全问题 -- 这个接口不能被外界使用者调用，只能在模块内，在对应的EventLoop线程中执行
    bool HasTimer(uint64_t id) {
        auto it = _timers.find(id);
        if(it == _timers.end()) {
            return false; // 没找到，没法刷新，没法延迟
        }
        return true;
    }
};

class EventLoop {
private:
    std::thread::id _thread_id; // 线程id
    int _event_fd; // eventfd唤醒IO时间监控有可能导致的阻塞
    std::unique_ptr<Channel> _event_channel;
    Poller _poller; // 进行所有描述符的事件监控
    using Functor = std::function<void()>;
    std::vector<Functor> _tasks; // 任务池
    std::mutex _mutex; // 实现任务池的线程安全
    TimerWheel _timer_wheel; // 定时器模块
public:
    // 执行任务池中的所有任务
    void RunAllTask() {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.swap(functor);
        }
        for(auto& f : functor) {
            f();
        }
        return;
    }
    static int CreateEventFd() {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0) {
            ERR_LOG("CREATE EVENTFD FAILED!");
            abort();
        }
        return efd;
    }
    void ReadEventFd() {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret < 0) {
            // EINTR -- 被信号打断 EAGAIN-- 无数据可读
            if (errno == EINTR || errno == EAGAIN) {
                return;
            }
            ERR_LOG("READ EVENTFD FAILED!");
            abort();
        }
        return;
    }
    void WakeUpEventFd() {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0) {
            if (errno == EINTR) {
                return;
            }
            ERR_LOG("READ EVENTFD FAILED!");
            abort();
        }
    }
public:
    EventLoop():_thread_id(std::this_thread::get_id()), _event_fd(CreateEventFd()), _event_channel(new Channel(this, _event_fd)), _timer_wheel(this) {
        // 给eventfd添加可读事件回调，读取eventfd事件通知次数
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventFd, this)); // ReadEventFd是类的成员函数，所以取地址＋类名称：：进行引用
        // 启动eventfd的读事件监控
        _event_channel->EnableRead();
    }
    // 判断要执行的任务是否处于当前线程中，如果是就执行，如果不是就压入队列
    void RunInLoop(const Functor& cb) {
        if (IsInLoop()) {
            return cb();
        }
        return QueueInLoop(cb);
    }
    // 将任务压入任务池
    void QueueInLoop(const Functor& cb) {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪，而导致的epoll阻塞; 
        // 其实就是给eventfd写入一个数据，eventfd就会触发可读事件
        WakeUpEventFd();
    }
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cb) {
        return _timer_wheel.TimerAdd(id, delay, cb);
    }
    void TimerRefresh(uint64_t id) {
        return _timer_wheel.TimerRefresh(id);
    }
    void TimerCancel(uint64_t id) {
        return _timer_wheel.TimerCancel(id);
    }
    bool HasTimer (uint64_t id) {
        return _timer_wheel.HasTimer(id);
    }
    // 用于判断当前线程是否是EventLoop线程
    bool IsInLoop() {
        return (_thread_id == std::this_thread::get_id());
    }
    void AssertInLoop() {
        assert(_thread_id == std::this_thread::get_id());
    }
    // 添加或修改描述符对应的线程
    void UpdateEvent(Channel* channel) {
        return _poller.UpdateEvents(channel);
    }
    // 移除描述符的监控
    void RemoveEvent(Channel* channel) {
        return _poller.RemoveEvent(channel);
    }
    // 事件监控 -- 就绪事件处理 -- 执行任务
    void Start() {
        while (1)
        {
            // 1.事件监控 
            std::vector<Channel*> actives;
            _poller.Poll(&actives);
            //  2.事件处理
            for (auto& channel : actives) {
                channel->HandleEvent();
            }
            // 3.执行任务
            RunAllTask();
        }
    }
};

class LoopThread {
private:
    /*用于实现_loop获取的同步关系，避免线程创建了，但是_loop还没实例化之前去获取_loop*/
    std::mutex _mutex;        // 互斥锁
    std::condition_variable _cond; // 条件变量
    EventLoop* _loop;    // EventLoop指针变量，需要在线程内实例化
    std::thread _thread;// EventLoop对应的线程
private:
    /*实例化EventLoop对象，唤醒_cond上有可能阻塞的线程，并且开始运行EventLoop模块功能，即运行start*/
    void ThreadEntry() {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;
            _cond.notify_all();
        }
        loop.Start();
    }
public:
    /*创建线程，设定线程入口函数*/
    LoopThread():_loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this)) {

    }
    /*返回当前线程关联的EventLoop对象指针*/
    EventLoop* GetLoop() {
        EventLoop* loop = nullptr;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _cond.wait(lock, [&](){ return _loop != nullptr; });// _loop为空就一直阻塞，等待被唤醒
            loop = _loop;
        }
        return loop;
    }
};

class LoopThreadPool {
private:
    int _thread_count; // 从属线程的数量
    int _next_loop_idx;
    EventLoop* _baseloop;// 主从EventLoop，运行在主线程，从属线程数量为0，则所有操作都在baseloop中进行
    std::vector<LoopThread*> _threads;// 保存所有的LoopThread对象
    std::vector<EventLoop*> _loops;// 从属线程数量大于0则从_loops中进行线程EventLoop分配
public:
    LoopThreadPool(EventLoop* baseloop):_thread_count(0), _next_loop_idx(0), _baseloop(baseloop) {}
    // 设置从属线程数量
    void SetThreadCount(int count) { _thread_count = count; }
    // 创建所有的从属线程
    void Create() {
        if (_thread_count > 0) {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for(int i = 0; i < _thread_count; i++) {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }
    }
    EventLoop* NextLoop() {
        if (_thread_count == 0) return _baseloop;
        _next_loop_idx = (_next_loop_idx + 1) % _thread_count;
        return _loops[_next_loop_idx];
    }
};

// struct Any
// {
//     /* data */
// };

class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info& type() = 0;
        virtual holder* clone() = 0;
    };
    template<class T>
    class placeholder: public holder
    {
    public:
        placeholder(const T& val):_val(val) {}
        // 获取子类对象保存的数据类型
        virtual const std::type_info& type() { return typeid(T); } 
        // 针对当前的对象自身，克隆出一个新的子类对象
        virtual holder* clone() { return new placeholder(_val); }    
    public:
        T _val;
    };
private:
    holder* _content;
public:
    Any():_content(nullptr) {}
    template<class T>
    Any(const T& val):_content(new placeholder<T>(val)) {}
    Any(const Any& other):_content(other._content ? other._content->clone() : nullptr) {}
    ~Any() { delete _content; }

    Any& swap(Any& other)
    {
        std::swap(_content, other._content);
        return *this;
    }

    // 获取在子类对象中保存的数据
    template<class T>
    T* get()
    {
        assert(typeid(T) == _content->type());
        return &((placeholder<T>*)_content)->_val;
    }
    // 赋值运算符的重载函数
    template<class T>
    Any& operator=(const T& val)
    {
        //为val构造一个临时的通用容器，然后和当前容器进行指针交换，临时对象释放时，原先保存的数据也就被释放了
        Any(val).swap(*this);
        return *this;
    }
    Any& operator=(const Any& other)
    {
        Any(other).swap(*this);
        return *this;
    }
};


class Connection;
// DISCONNECTED -- 连接关闭状态         CONNECTING -- 连接建立成功-待处理状态
// CONNECTED -- 连接建立完成，各种设置已完成，可以通信的状态；     DISCONNECTING -- 待关闭状态
typedef enum {DISCONNECTED, CONNECTING, CONNECTED, DISCONNECTING} ConnStatu;
using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection> {
private:
    uint64_t _conn_id;  // 连接的唯一ID，便于连接的管理和查找
    // uint64_t _timer_id; // 定时器ID，必须是唯一的，使用连接_conn_id作为定时器的ID
    int _sockfd;       //  连接管理的文件描述符
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标准，默认为false
    EventLoop* _loop;  // 连接所关联的EventLoop
    ConnStatu _statu;  //  连接状态
    Socket _socket;    //   套接字操作管理
    Channel _channel;  //   连接的事件管理
    Buffer _in_buffer; // 输入缓冲区 -- 存放从socket中读到的数据
    Buffer _out_buffer; // 输出缓冲区 -- 存放要发送给对端的数据
    Any _context;       // 请求的接收处理上下文

    // 这四个回调函数，是让服务器模块来设置的(其实服务器模块的处理回调也是组件使用者设置的)
    // 换句话说，这几个回调都是组件使用者使用的
    using ConnectedCallback = std::function<void(const PtrConnection&)>;
    using MessageCallback = std::function<void(const PtrConnection&, Buffer*)>;
    using ClosedCallback = std::function<void(const PtrConnection&)>;
    using AnyEventCallback = std::function<void(const PtrConnection&)>;

    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    // 组件内的连接关闭回调 -- 组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭就应该从管理的地方移除自己的信息
    ClosedCallback _server_closed_callback;
private:
    /*五个channel的事件回调函数*/
    // 描述符触发可读事件后调用的函数，接收socket数据放到接收缓冲区中，然后调用_message_callback
    void HandleRead() {
        // 1. 接收socket的数据放到缓冲区
        char buffer[65536];
        ssize_t ret = _socket.NonBlockRecv(buffer, 65535);
        if (ret < 0) {
            // 出错了
            return ShutdownInLoop();
        }
        // 这里的等于0，表示没有读取到数据，并不是连接断开，连接断开返回的是-1
        // 将数据放入输入缓冲区，顺便把写偏移向后移动
        _in_buffer.WriteAndPush(buffer, ret);
        //2.调用message_callback进行业务处理
        if (_in_buffer.ReadableSize() > 0) {
            // shared_from_this从当前对象自身获取自身的shared_ptr管理对象
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }
    // 描述符触发可写事件后调用的函数，将发送缓冲区中的数据进行发送
    void HandleWrite() {
        // outbuffer中保存的数据就是要发送的数据
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadableSize());
        if (ret < 0) {
            // 发送错误就关闭连接了
            if (_in_buffer.ReadableSize() > 0) {
                // shared_from_this从当前对象自身获取自身的shared_ptr管理对象
                _message_callback(shared_from_this(), &_in_buffer);
            }
            return ReleaseInLoop();//这时候就是实际的关闭释放操作了
        }
        _out_buffer.MoveReadOffset(ret);//千万不要忘了把读偏移向后移动
        if (_out_buffer.ReadableSize() == 0) {
            _channel.DisableWrite();// 没有数据待发送，关闭事件监控
            // 如果当前连接待关闭状态，如果有数据，发送完数据释放连接，如果没有数据，直接释放
            if(_statu == DISCONNECTING) {
                return ReleaseInLoop();
            }
        }
        return;
    }
    // 描述符触发挂断事件后调用的函数，
    void HandleClose() { 
        /*一旦连接挂断了，套接字就什么都干不了了，因此有数据就处理一下，完毕就关闭连接*/
        if (_in_buffer.ReadableSize() > 0) {
            // shared_from_this从当前对象自身获取自身的shared_ptr管理对象
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return ReleaseInLoop();
    }
    // 描述符触发出错事件后调用的函数，
    void HandleError() {
        HandleClose();
    }
    // 描述符触发任意事件后调用的函数，1.刷新连接活跃度：延迟定时销毁任务，2.调用组建使用者的任意回调事件
    void HandleEvent() {
        if (_enable_inactive_release == true) { _loop->TimerRefresh(_conn_id); }
        if (_event_callback) { _event_callback(shared_from_this()); }
    }

    // 连接获取之后，所处的状态下要进行各种设置 (给channel设置事件回调，启动读监控)
    void EstablishedInLoop() {
        // 1.修改连接状态
        assert(_statu == CONNECTING);// 当前状态一定是上层的半连接状态
        _statu = CONNECTED;// 当前函数处理完毕，连接进入已完成连接状态
        // 2.启动读事件监控
        // 一旦启动读事件监控就有可能立即触发读事件，如果这时候启动了非活跃连接销毁
        _channel.EnableRead();
        // 3.调用回调函数
        if (_connected_callback) _connected_callback(shared_from_this());
    }
    // 这个接口才是实际到达释放接口
    void ReleaseInLoop() {
        //1. 修改连接状态，将其置为DISCONNECTED
        _statu = DISCONNECTED;
        //2. 移除事件监控
        _channel.Remove();
        //3. 关闭描述符
        _socket.Close();
        //4. 如果当前的定时器队列中还有定时销毁任务，则取消任务
        if (_loop->HasTimer(_conn_id)) CancelInactiveReleaseInLoop();
        //5. 调用关闭回调函数：先移除服务器的连接信息导致Connection被释放，再处理就会出错，因此先调用用户的回调函数
        //关闭用户的一些处理
        if (_closed_callback) _closed_callback(shared_from_this());
        //移除服务器内部管理的连接信息
        if(_server_closed_callback) _server_closed_callback(shared_from_this());
    }
    // 这个接口并不是实际的发送接口，只是把数据放到缓冲区，启动了可写事件监控
    void SendInLoop(Buffer buf) {
        if (_statu == DISCONNECTED) return;
        //1. 把数据放到缓冲区
        _out_buffer.WriteBufferAndPush(buf);
        //2. 启动可写事件监控
        if (_channel.WriteAble() == false) {
            _channel.EnableWrite();
        }
    }
    // 这个关闭操作，并不是实际的释放连接操作，需要去判断有没有数据待处理，待发送
    void ShutdownInLoop() {
        _statu = DISCONNECTING;// 设置连接为半关闭状态
        if (_in_buffer.ReadableSize() > 0) {
            if (_message_callback) _message_callback(shared_from_this(), &_in_buffer);
        }
        // 要么写入数据的时候出错关闭，要么没有待发送数据，直接关闭
        if (_out_buffer.ReadableSize() > 0) {
            if (_channel.WriteAble() == false) {
                _channel.EnableWrite();
            }
        }
        if (_out_buffer.ReadableSize() == 0) {
            ReleaseInLoop();
        }
    }
    // 启动非活跃连接超时释放规则
    void EnableInactiveReleaseInLoop(int sec) {
        //1. 将判断标准_enable_inactive_release 置为 true
        _enable_inactive_release = true;
        //2. 如果当前定时销毁任务存在，刷新延迟即可，如果不存在，添加定时销毁任务
        if (_loop->HasTimer(_conn_id)) {
            return _loop->TimerRefresh(_conn_id);
        }
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::ReleaseInLoop, this));
    } 
    void CancelInactiveReleaseInLoop() {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id)) {
            _loop->TimerCancel(_conn_id);
        }
    }
    void UpgradeInLoop(const Any& context, const ConnectedCallback& conn, 
                        const MessageCallback& msg, 
                        const ClosedCallback& closed, 
                        const AnyEventCallback& event) {
        _context = context;
        _connected_callback = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }
public:
    Connection(EventLoop* loop, uint64_t conn_id, int sockfd):_conn_id(conn_id), _sockfd(sockfd),
        _enable_inactive_release(false), _loop(loop), _statu(CONNECTING), _socket(_sockfd), 
        _channel(loop, _sockfd) {
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
    }
    ~Connection() { DBG_LOG("RELEASE CONNECTION: %p", this); }
    int Fd() { return _sockfd; }
    int Id() { return _conn_id; }
    // 是否处于CONNECTED状态
    bool Connected() { return _statu == CONNECTED; }
    // 设置上下文 -- 连接建立完成时
    void SetContext(const Any& context) { _context = context; }
    // 获取上下文 -- 返回指针才能保证每次访问的是同一个上下文
    Any* GetContext() { return &_context; }
    //
    void SetConnectedCallback(const ConnectedCallback& cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback& cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback& cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback& cb) { _event_callback = cb; }
    void SetSvrClosedCallback(const ClosedCallback& cb) { _server_closed_callback = cb; }
    // 连接建立就绪后，进行channel回调设置，启动读监控，调用_connected_callback
    void Established() {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }
    // 发送数据，将数据写入发送缓冲区，启动写事件监控
    void Send(const char* data, size_t len) {
        //外界传入的data，可能是个临时的空间，我们现在只是把发送操作压入了任务池，有可能并没有立即执行该任务
        //因此有可能执行的时候，data指向的空间已经被释放了
        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, buf));
    }
    // 提供给组件使用者的关闭接口 -- 并不实际关闭，需要判断有没有数据待处理
    void Shutdown() {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }
    // 启动非活跃销毁，并且定义多长时间未通信就是非活跃，添加定时任务
    void EnableInactiveRelease(int sec) {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    } 
    // 取消非活跃销毁
    void CancelInactiveRelease() {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }
    // 切换协议 -- 重置上下文以及阶段性回调处理函数 -- 非线程安全，这个接口必须在EventLoop线程中进行
    // 防备新的事件触发后，处理时，切换任务没有被执行--导致数据使用原协议处理了
    void Upgrade(const Any& context, const ConnectedCallback& conn, const MessageCallback& msg, const ClosedCallback& closed, const AnyEventCallback& event) {
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    }
};

class Acceptor {
private:
    Socket _socket;// 用于创建监听套接字
    EventLoop* _loop;// 用于监听套件字的事件监控
    Channel _channel;// 用于监听套接字的事件管理

    using AcceptCallback = std::function<void(int)>;
    AcceptCallback _accept_callback;
private:
    /*监听套接字的读事件回调 -- 获取新连接，调用_accept_callback函数进行新连接处理*/
    void HandleRead() {
        // DBG_LOG("HandleRead FUNCTION");

        int newfd = _socket.Accept();
        if (newfd < 0) {
            return;
        }
        if (_accept_callback) _accept_callback(newfd);
    }
    int CreatServer(int port) {
        bool ret = _socket.CreateServer(port);
        assert(ret == true);
        return _socket.Fd();
    }
public:
    Acceptor(EventLoop* loop, int port):_socket(CreatServer(port)), _loop(loop), _channel(loop, _socket.Fd()) {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
    }
    void SetAcceptCallback(const AcceptCallback& cb) { _accept_callback = cb; }
    void Listen() { _channel.EnableRead(); }
};

class TcpServer {
private:
    uint64_t _next_id;      //这是一个自增长的连接ID
    int _port;
    int _timeout;            //这是非活跃连接的统计时间--多长时间无通信就是非活跃连接
    bool _enable_inactive_release;//是否开启了非活跃状态连接超时销毁的标志
    Acceptor _acceptor;     //这是监听套接字的管理对象
    EventLoop _baseloop;    //这是主线程的EventLoop对象，赋值监听事件的处理
    LoopThreadPool _pool;   //这是从属EventLoop线程池
    std::unordered_map<uint64_t, PtrConnection> _conns;//保存管理所有连接对应的shared_ptr对象

    using ConnectedCallback = std::function<void(const PtrConnection&)>;
    using MessageCallback = std::function<void(const PtrConnection&, Buffer*)>;
    using ClosedCallback = std::function<void(const PtrConnection&)>;
    using AnyEventCallback = std::function<void(const PtrConnection&)>;
    using Functor = std::function<void()>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    ClosedCallback _server_closed_callback;
private:
    //为新连接构造一个Connection进行管理
    void NewConnection(int fd) {
        // DBG_LOG("NewConnection FUNCTION");
        _next_id++;
        PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));
        conn->SetMessageCallback(_message_callback); 
        conn->SetClosedCallback(_closed_callback);
        conn->SetConnectedCallback(_connected_callback);
        conn->SetAnyEventCallback(_event_callback);
        conn->SetSvrClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        if (_enable_inactive_release == true) conn->EnableInactiveRelease(_timeout);// 启动非活跃销毁
        conn->Established();// 就绪初始化
        _conns.insert(std::make_pair(_next_id, conn));
    }
    void RemoveConnectionInLoop(const PtrConnection& conn) {
        int id = conn->Id();
        auto it = _conns.find(id);
        if(it != _conns.end()) {
            _conns.erase(id);
        }
    }
    //从管理Connection的_conns中移除连接信息
    void RemoveConnection(const PtrConnection& conn) {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }
    void RunAfterInLoop(const Functor& task, int delay) {
        _next_id++;
        _baseloop.TimerAdd(_next_id, delay, task);
    }
public:
    TcpServer(int port):_port(port), _next_id(0), _enable_inactive_release(false), _acceptor(&_baseloop, port), _pool(&_baseloop) {
        
        _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        _acceptor.Listen();//将监听套接字挂到baseloop上开始监控事件
    }
    void SetThreadCount(int count) {
        return _pool.SetThreadCount(count);
    }
    void SetConnectedCallback(const ConnectedCallback& cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback& cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback& cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback& cb) { _event_callback = cb; }
    void SetSvrClosedCallback(const ClosedCallback& cb) { _server_closed_callback = cb; }
    void EnableInactiveRelease(int timeout) {
        _timeout = timeout;
        _enable_inactive_release = true;
    }
    //用于添加一个定时任务
    void RunAfter(const Functor& task, int delay) {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }
    void Start() { 
        _pool.Create();//创建线程池中的从属线程
        return _baseloop.Start(); 
    }
};

void Channel::Remove() {/*后面调用EventLoop的接口*/ return _loop->RemoveEvent(this); }
void Channel::Update() { return _loop->UpdateEvent(this); }

void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cb) {
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}
void TimerWheel::TimerRefresh(uint64_t id) {
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}
void TimerWheel::TimerCancel(uint64_t id) {
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}


class NetWork {
public:
    NetWork() {
        DBG_LOG("SIGPIPE INIT!");
        signal(SIGPIPE, SIG_IGN);
    }
};

static NetWork nw;
#endif